{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from astropy.io import fits\n",
    "import math\n",
    "from scipy import stats\n",
    "import numpy as np\n",
    "from reproject import reproject_interp, reproject_exact\n",
    "from aplpy import FITSFigure\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listing all the filament names\n",
    "Names_List = ['Fil1', 'Fil2', 'Fil4', 'Fil5', 'Snake', 'Fil8', 'Fil10', 'G24', 'G47', 'G49']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to calculate the circular mean and standard deviation\n",
    "def circ_stat(array):\n",
    "    # Takes a numpy array in degrees\n",
    "    # Conversion from degrees to radians\n",
    "    conv_rad = math.pi/180.0\n",
    "    conv_deg = conv_rad**-1.0\n",
    "    # Circular mean of the array\n",
    "    circular_mean = conv_deg * stats.circmean(conv_rad*array, \n",
    "                                              low=-math.pi/2.0, \n",
    "                                              high=math.pi/2.0,\n",
    "                                              nan_policy='omit')\n",
    "    # Circular standard deviation of the array\n",
    "    circular_stdev = conv_deg * stats.circstd(conv_rad*array, \n",
    "                                              low=-math.pi/2.0,  \n",
    "                                              high=math.pi/2.0, \n",
    "                                              nan_policy='omit')\n",
    "    # Returning the values\n",
    "    return circular_mean, circular_stdev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to test the reprojection\n",
    "def Test_Data(Name,PlanckI, HAWCI, PlanckHead):\n",
    "    # Test data\n",
    "    TestFit = fits.HDUList()\n",
    "    TestFit.append(fits.ImageHDU(data=PlanckI, header=PlanckHead))\n",
    "    TestFit.append(fits.ImageHDU(data=HAWCI, header=PlanckHead))\n",
    "    # Printing the comparison plots\n",
    "    TestHAWC = FITSFigure(TestFit[0])\n",
    "    TestHAWC.show_colorscale()\n",
    "    TitleHAWC = Name+' HAWC+'\n",
    "    TestHAWC.set_title(TitleHAWC)\n",
    "    TestPlanck = FITSFigure(TestFit[1])\n",
    "    TestPlanck.show_colorscale()\n",
    "    TitlePlanck = Name+' Planck'\n",
    "    TestPlanck.set_title(TitlePlanck)\n",
    "    return TestHAWC, TestPlanck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reprojecting Fil1\n",
      "Reprojecting Fil2\n",
      "Reprojecting Fil4\n",
      "Reprojecting Fil5\n",
      "Reprojecting Snake\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: FITSFixedWarning: 'datfix' made the change 'Set MJD-OBS to 58312.400043 from DATE-OBS'. [astropy.wcs.wcs]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reprojecting Fil8\n",
      "Reprojecting Fil10\n",
      "Reprojecting G24\n",
      "Reprojecting G47\n",
      "Reprojecting G49\n"
     ]
    }
   ],
   "source": [
    "# Creating the lists for the new FITS containers\n",
    "HAWCData = []\n",
    "PlanckData = []\n",
    "# Reprojecting the HAWC+ data and masking the Planck data\n",
    "for i in range(0,len(Names_List)):\n",
    "    print('Reprojecting '+Names_List[i])\n",
    "    # Opening the fits files\n",
    "    SourcePlanck = fits.open(Names_List[i]+'/Data/'+Names_List[i]+'_Planck.fits')\n",
    "    SourceHawc = fits.open(Names_List[i]+'/Data/'+Names_List[i]+'_Gal.fits')\n",
    "    # Reprojecting the HAWC+ data to the Planck size\n",
    "    ProjI, footprint = reproject_exact(SourceHawc[0], SourcePlanck[0].header)\n",
    "    ProjQ, footprint = reproject_exact(SourceHawc[1], SourcePlanck[0].header)\n",
    "    ProjU, footprint = reproject_exact(SourceHawc[2], SourcePlanck[0].header)\n",
    "    # Size\n",
    "    SizePlanck = np.shape(SourcePlanck[0].data)\n",
    "    # Masking NaN pixels from HAWC+ in the Planck data\n",
    "    for k in range(0,SizePlanck[0]):\n",
    "        for j in range(0,SizePlanck[1]):\n",
    "            # Checking if there is a positive non-NaN pixel\n",
    "            if ProjI[k,j] > 0.0:\n",
    "                continue\n",
    "            else:\n",
    "                SourcePlanck[0].data[k,j] = np.nan # Stokes I\n",
    "                SourcePlanck[1].data[k,j] = np.nan # Stokes Q\n",
    "                SourcePlanck[2].data[k,j] = np.nan # Stokes U\n",
    "                SourcePlanck[3].data[k,j] = np.nan # Polarized Intensity Ip\n",
    "                SourcePlanck[4].data[k,j] = np.nan # Polarization Fraction P\n",
    "                SourcePlanck[5].data[k,j] = np.nan # Polarization Angle\n",
    "                SourcePlanck[6].data[k,j] = np.nan # Rotated Polarization Angle\n",
    "    # Testing the reprojection (optional)\n",
    "    # TestHAWC, TestPlanck = Test_Data(Names_List[i],SourcePlanck[0].data,ProjI,SourcePlanck[0].header)\n",
    "    # Creating a new Planck container\n",
    "    PlanckFITS = fits.HDUList()\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[0].data,SourcePlanck[0].header))\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[1].data,SourcePlanck[1].header))\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[2].data,SourcePlanck[2].header))\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[3].data,SourcePlanck[3].header))\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[4].data,SourcePlanck[4].header))\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[5].data,SourcePlanck[5].header))\n",
    "    PlanckFITS.append(fits.ImageHDU(SourcePlanck[6].data,SourcePlanck[6].header))\n",
    "    PlanckData.append(PlanckFITS)\n",
    "    #print(PlanckData[i].info())\n",
    "    # Creating a new HAWC+ container\n",
    "    HAWCFITS = fits.HDUList()\n",
    "    HAWCFITS.append(fits.ImageHDU(ProjI,SourcePlanck[0].header))\n",
    "    HAWCFITS.append(fits.ImageHDU(ProjQ,SourcePlanck[1].header))\n",
    "    HAWCFITS.append(fits.ImageHDU(ProjU,SourcePlanck[2].header))\n",
    "    HAWCData.append(HAWCFITS)\n",
    "    #print(HAWCData[i].info())\n",
    "    # Closing the fits files (cleanup)\n",
    "    SourcePlanck.close()\n",
    "    SourceHawc.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Info for the Planck data\n",
      "Filename: (No file associated with this HDUList)\n",
      "No.    Name      Ver    Type      Cards   Dimensions   Format\n",
      "  0  STOKES I      1 PrimaryHDU      23   (120, 120)   float32   \n",
      "  1  STOKES Q      1 ImageHDU        24   (120, 120)   float32   \n",
      "  2  STOKES U      1 ImageHDU        24   (120, 120)   float32   \n",
      "  3  POL FLUX      1 ImageHDU        24   (120, 120)   float32   \n",
      "  4  PERCENT POL    1 ImageHDU        24   (120, 120)   float32   \n",
      "  5  POL ANGLE     1 ImageHDU        24   (120, 120)   float32   \n",
      "  6  ROTATED POL ANGLE    1 ImageHDU        24   (120, 120)   float32   \n",
      "Info for the HAWC+ reprojected data\n",
      "Filename: (No file associated with this HDUList)\n",
      "No.    Name      Ver    Type      Cards   Dimensions   Format\n",
      "  0  STOKES I      1 PrimaryHDU      23   (120, 120)   float64   \n",
      "  1  STOKES Q      1 ImageHDU        24   (120, 120)   float64   \n",
      "  2  STOKES U      1 ImageHDU        24   (120, 120)   float64   \n"
     ]
    }
   ],
   "source": [
    "print('Info for the masked Planck data')\n",
    "PlanckData[0].info()\n",
    "print('Info for the HAWC+ reprojected data')\n",
    "HAWCData[0].info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statistics for Fil1\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(-5.908609731392261, 9.977214647018007)\n",
      "Planck Angle from Stokes Q and U sum: -7.161864863655863 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: 18.262863133827064 degrees\n",
      "\n",
      "Statistics for Fil2\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(-9.386186886925925, 11.919622785636472)\n",
      "Planck Angle from Stokes Q and U sum: -10.621178947122546 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -16.64417381692512 degrees\n",
      "\n",
      "Statistics for Fil4\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(3.6091923963616304, 7.46419879119483)\n",
      "Planck Angle from Stokes Q and U sum: 2.67289890903611 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: 2.5692312626366967 degrees\n",
      "\n",
      "Statistics for Fil5\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(1.1107091979709662, 10.077444772321877)\n",
      "Planck Angle from Stokes Q and U sum: 0.13149037295029556 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -7.027926327784094 degrees\n",
      "\n",
      "Statistics for Snake\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(-12.086427043209596, 7.192770169407218)\n",
      "Planck Angle from Stokes Q and U sum: -13.141215661212833 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -24.157803359875885 degrees\n",
      "\n",
      "Statistics for Fil8\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(-5.456861019687617, 4.607029739555729)\n",
      "Planck Angle from Stokes Q and U sum: -5.662892765384647 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -2.6644971925494843 degrees\n",
      "\n",
      "Statistics for Fil10\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(6.449130411739585, 9.523809862578544)\n",
      "Planck Angle from Stokes Q and U sum: 8.131931018263387 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: 12.59486655117524 degrees\n",
      "\n",
      "Statistics for G24\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(-1.0664017608250935, 10.717604961339758)\n",
      "Planck Angle from Stokes Q and U sum: -2.5037896150455294 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -4.4511024912185295 degrees\n",
      "\n",
      "Statistics for G47\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(26.049724272925165, 20.12488950130145)\n",
      "Planck Angle from Stokes Q and U sum: 22.72085308538461 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -17.459741364849673 degrees\n",
      "\n",
      "Statistics for G49\n",
      "Planck circular mean and standard deviation for the polarization angles in degrees\n",
      "(-35.33152788324396, 18.29116042813324)\n",
      "Planck Angle from Stokes Q and U sum: -39.884783790357325 degrees\n",
      "HAWC+ Angle from Stokes Q and U sum: -12.083005017423426 degrees\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Containers\n",
    "ListSumPlanckO = []\n",
    "ListSumHAWCO = []\n",
    "# Satistics for the Planck Data\n",
    "for i in range(0,len(Names_List)):\n",
    "    print('Statistics for '+Names_List[i])\n",
    "    print('Planck circular mean and standard deviation for the polarization angles in degrees')\n",
    "    print(circ_stat(PlanckData[i][5].data))\n",
    "    # Calculating the sum Q and U angles for Planck\n",
    "    SumPlanckQ = np.nansum(PlanckData[i][1].data)\n",
    "    SumPlanckU = np.nansum(PlanckData[i][2].data)\n",
    "    SumPlanckO = 0.5 * np.arctan2(SumPlanckU,SumPlanckQ) * 180.0 / math.pi\n",
    "    ListSumPlanckO.append(SumPlanckO)\n",
    "    print('Planck Angle from Stokes Q and U sum: '+str(SumPlanckO)+' degrees')\n",
    "    # Calculating the sum Q and U angles for HAWC+\n",
    "    SumHAWCQ = np.nansum(HAWCData[i][1].data)\n",
    "    SumHAWCU = np.nansum(HAWCData[i][2].data)\n",
    "    SumHAWCO = 0.5 * np.arctan2(SumHAWCU,SumHAWCQ) * 180.0 / math.pi\n",
    "    ListSumHAWCO.append(SumHAWCO)\n",
    "    print('HAWC+ Angle from Stokes Q and U sum: '+str(SumHAWCO)+' degrees')\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to convert angles to 0 to 180 values\n",
    "def fix_angles180(OneDarray):\n",
    "    OneDarray2 = np.copy(OneDarray)\n",
    "    # Printing the input array\n",
    "    print('Input Array')\n",
    "    print(OneDarray)\n",
    "    # Checking each element that needs to be fixed\n",
    "    for i in range(0, np.shape(OneDarray)[0]):\n",
    "        if OneDarray[i] > 180.0:\n",
    "            OneDarray2[i] = OneDarray[i] - 180.0\n",
    "        if OneDarray[i] < 0.0:\n",
    "            OneDarray2[i] = OneDarray[i] + 180.0\n",
    "    # Printing the output array\n",
    "    print('Output Array')\n",
    "    print(OneDarray2)\n",
    "    return OneDarray2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Array\n",
      "[108.26286313  73.35582618  92.56923126  82.97207367  65.84219664\n",
      "  87.33550281 102.59486655  85.54889751  72.54025864  77.91699498]\n",
      "Output Array\n",
      "[108.26286313  73.35582618  92.56923126  82.97207367  65.84219664\n",
      "  87.33550281 102.59486655  85.54889751  72.54025864  77.91699498]\n",
      "Input Array\n",
      "[ 82.83813514  79.37882105  92.67289891  90.13149037  76.85878434\n",
      "  84.33710723  98.13193102  87.49621038 112.72085309  50.11521621]\n",
      "Output Array\n",
      "[ 82.83813514  79.37882105  92.67289891  90.13149037  76.85878434\n",
      "  84.33710723  98.13193102  87.49621038 112.72085309  50.11521621]\n"
     ]
    }
   ],
   "source": [
    "# Changing from -90 to 90 to 0 to 180. \n",
    "Theta_B_180 = fix_angles180(np.array(ListSumHAWCO)+90.0)\n",
    "Theta_PlaB_180 = fix_angles180(np.array(ListSumPlanckO)+90.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 512x384 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the comparison on a 0 to 180 degrees plot (Planck vs HAWC+)\n",
    "FigSize=[5.12,3.84]\n",
    "PvH_plot = plt.figure(figsize=(FigSize[0],FigSize[1]))\n",
    "plt.xlabel('HAWC+ Mean Magnetic Field Angle (degree)')\n",
    "plt.ylabel('Planck Mean Magnetic Field Angle (degree)')\n",
    "axes = plt.gca() # Calling the axes object of the figure\n",
    "# plt.errorbar(Theta_B_180, Theta_PlaB_180, xerr=Uncertain_B, yerr=Uncertain_PlaB,\n",
    "#              ecolor='gray',linestyle='None',alpha=0.6)\n",
    "plt.plot(Theta_B_180, Theta_PlaB_180, '.', color='black', markersize=8)\n",
    "axes.xaxis.set_ticks_position('both') # Adding ticks to each side\n",
    "axes.yaxis.set_ticks_position('both') # Adding ticks to each side\n",
    "plt.xlim(0.0,180.0)\n",
    "plt.ylim(0.0,180.0)\n",
    "plt.tight_layout() # Using all available space in the plot window\n",
    "# Creating disk lines\n",
    "plt.axvline(x=90.0, color='black', linestyle='--', linewidth=1)\n",
    "plt.axhline(y=90.0, color='black', linestyle='--', linewidth=1)\n",
    "# Creating zero difference line\n",
    "RefX = np.arange(0.0, 180.0, 0.1)\n",
    "RefY = np.arange(0.0, 180.0, 0.1)\n",
    "plt.plot(RefX, RefY, 'black')\n",
    "# Creating difference lines\n",
    "Ref45Xa = np.arange(0.0, 135, 0.1)\n",
    "Ref45Ya = np.arange(45.0, 180.0, 0.1)\n",
    "plt.plot(Ref45Xa, Ref45Ya, 'black', linestyle=':', linewidth=1)\n",
    "Ref45Yb = np.arange(0.0, 135, 0.1)\n",
    "Ref45Xb = np.arange(45.0, 180.0, 0.1)\n",
    "plt.plot(Ref45Xb, Ref45Yb, 'black', linestyle=':', linewidth=1)\n",
    "Ref45Xc = np.arange(0.0, 45.0, 0.1)\n",
    "Ref45Yc = np.arange(135.0, 180.0, 0.1)\n",
    "plt.plot(Ref45Xc, Ref45Yc, 'black', linestyle=':', linewidth=1)\n",
    "Ref45Yd = np.arange(0.0, 45.0, 0.1)\n",
    "Ref45Xd = np.arange(135.0, 180.0, 0.1)\n",
    "plt.plot(Ref45Xd, Ref45Yd, 'black', linestyle=':', linewidth=1)\n",
    "Ref90Xa = np.arange(0.0, 90.0, 0.1)\n",
    "Ref90Ya = np.arange(90.0, 180.0, 0.1)\n",
    "plt.plot(Ref90Xa, Ref90Ya, 'black', linestyle='-.', linewidth=1)\n",
    "Ref90Yb = np.arange(0.0, 90.0, 0.1)\n",
    "Ref90Xb = np.arange(90.0, 180.0, 0.1)\n",
    "plt.plot(Ref90Xb, Ref90Yb, 'black', linestyle='-.', linewidth=1)\n",
    "# Adding the labels to the difference lines\n",
    "plt.text(15, 5, r'$\\Delta \\theta = 0^{\\circ}$')\n",
    "plt.text(60, 5, r'$\\Delta \\theta = 45^{\\circ}$')\n",
    "plt.text(105, 5, r'$\\Delta \\theta = 90^{\\circ}$')\n",
    "plt.text(150, 5, r'$\\Delta \\theta = 45^{\\circ}$')\n",
    "plt.text(10, 170, r'$\\Delta \\theta = 45^{\\circ}$')\n",
    "plt.text(55, 170, r'$\\Delta \\theta = 90^{\\circ}$')\n",
    "plt.text(100, 170, r'$\\Delta \\theta = 45^{\\circ}$')\n",
    "plt.text(145, 170, r'$\\Delta \\theta = 0^{\\circ}$')\n",
    "# Creating label positions for each filament\n",
    "FilNames = ['Fil1', 'Fil2', 'Fil4', 'Fil5', 'Fil6', 'Fil8', 'Fil10', 'G24', 'G47', 'G49']\n",
    "NameShiftX = [5,5,5,5,5,5,5,5,5,5]\n",
    "NameShiftY = [5,5,5,5,5,5,5,5,5,5]\n",
    "FilLabelX = Theta_B_180 + NameShiftX\n",
    "FilLabelY = Theta_PlaB_180 + NameShiftY\n",
    "# Adding the labels to the points\n",
    "for i in range(0,len(FilNames)):\n",
    "    plt.text(FilLabelX[i], FilLabelY[i], FilNames[i], horizontalalignment='center')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving figure\n",
    "PvH_plot.savefig('All/Planck_Hawc_SumQU_Comparison.png',dpi=300)\n",
    "PvH_plot.savefig('All/Planck_Hawc_SumQU_Comparison.pdf',dpi=300)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PoLiteWIP",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
